Static local coordination avoidance for distributed objects

In high-throughput, distributed systems, such as large-scale banking infrastructure, synchronization between actors becomes a bottle-neck in high-contention scenarios. This results in delays for users, and reduces opportunities for scaling such systems. This paper proposes Static Local Coordination Avoidance, which analyzes application invariants at compile time to detect whether messages are independent, so that synchronization at run time is avoided, and parallelism is increased. Analysis shows that in industry scenarios up to 60% of operations are independent. Initial performance evaluation shows that, in comparison to a standard 2-phase commit baseline, throughput is increased, and latency is reduced. As a result, scalability bottlenecks in high-contention scenarios in distributed actor systems are reduced for independent messages

Contract-based return-value commutativity: safely exploiting contract-based commutativity for faster serializable transactions

A key challenge of designing distributed software systems is maintaining data consistency. We can define data consistency and data isolation guarantees --e.g. serializability-- in terms of schedules of atomic reads and writes, but this excludes schedules that would be semantically consistent. Others use manually provided information on "non-conflicting operations" to define guarantees that work for more applica

Path-Sensitive Atomic Commit: Local Coordination Avoidance for Distributed Transactions

Context: Concurrent objects with asynchronous messaging are an increasingly popular way to struc-ture highly available, high performance, large-scale software systems. To ensure data-consistency and sup-port synchronization between objects such systems often use distributed transactions with Two-Phase Locking(2pl) for concurrency control and Two-Phase commit (2pc ) as atomic commitment protocol. Inquiry: In highly available, high-throughput systems, such as large banking infrastructure, however,2plbecomes a bottleneck when objects are highly contended, when an object is queuing a lot of messages becauseof locking. <br?. Approach: In this paper we introduce Path-Sensitive Atomic Commit (psac) to address this situation. Westart from message handlers (or methods), which are decorated with pre- and post-conditions, describingtheir guards and effect. Knowledge: This allows thepsaclock mechanism to check whether the effect of two incoming messages atthe same time are independent, and to avoid locking if this is the case. As a result, more messages are directlyaccepted or rejected, and higher overall throughput is obtained. Grounding: We have implementedpsacfor a state machine-based DSL called Rebel, on top of a runtimebased on the Akka actor framework. Our performance evaluation shows thatpsacexhibits the same scalabilityand latency characteristics as standard2pl/2pc, and obtains up to 1.8 times median higher throughput incongested scenarios. Importance: We believepsacis a step towards enabling organizations to build scalable distributed applica-tions, even if their consistency requirements are not embarrassingly paralle

Automated Validation of State-Based Client-Centric Isolation with TLA+

Clear consistency guarantees on data are paramount for the design and implementation of distributed systems. When implementing distributed applications

Path-Sensitive Atomic Commit: Local Coordination Avoidance for Distributed Transactions Evaluation Data

Evaluation Data accompanying the paper titled: Path-Sensitive Atomic Commit: Local Coordination Avoidance for Distributed Transaction

TimSoethout/tla-ci: TLA+ specifications used in "Automated Validation of State-Based Client-Centric Isolation with TLA+".

TLA+ specifications accompanying paper: Automated Validation of State-Based Client-Centric Isolation with TLA+ (https://doi.org/10.1007/978-3-030-67220-1_4). Based on Crooks' Isolation (https://dl.acm.org/doi/10.1145/3087801.3087802)

TimSoethout/cbc-artifacts: Artifacts for AGERE'21 paper "Contract-Based Return-Value Commutativity: Safely exploiting contract-based commutativity for faster serializable transactions"

Artifacts accompanying paper: Contract-Based Return-Value Commutativity: Safely exploiting contract-based commutativity for faster serializable transaction

Static Local Coordination Avoidance for Distributed Objects Artifacts

This folder contains the experiment data, scripts to reproduce and source code for the Rebel runtime in Scala, and the SIE analysis in Rascal